import { Context, Telegraf } from "telegraf";
import { message } from "telegraf/filters";
import { InputMediaPhoto } from "telegraf/types";
import { Update } from "typegram";
import dotenv_config from "dotenv";
import { readFileSync, writeFileSync } from "fs";

dotenv_config.config();

interface Post {
    media_group_id: string;
    caption: string;
    photos: string[];
}

interface BotContext extends Context<Update> {
    posts: Post[];
}

interface StartData {
    admins: number[];
    time: string[];
    posts: Post[];
}

function requireUncached(module: string) {
    const content = readFileSync(module, { encoding: "utf-8" });
    let data: StartData;
    try {
        data = JSON.parse(content);
    } catch (e) {
        console.log(content);
        console.error(e);
        process.exit();
    }
    return data;
}

function save_data(posts: Post[]) {
    const data: StartData = requireUncached("./info.json");
    data.posts = posts;
    writeFileSync("./info.json", JSON.stringify(data, null, 2));
}
const start_data: StartData = requireUncached("./info.json");
const admins = start_data.admins;
const time = start_data.time;

const bot: Telegraf<BotContext> = new Telegraf(process.env.TOKEN || "");

bot.on("message", async (ctx, next) => {
    if (ctx.chat.type !== "private") next();
    const message = ctx.message;
    let t = 1;
    admins.forEach(async (admin) => {
        try {
            await ctx.telegram.sendMessage(
                `${admin}`,
                `Вам новое сообщение от пользователя с id: ${
                    message.chat.id
                }\n${
                    message.from.username
                        ? "Ник: @" + message.from.username
                        : ""
                }`
            );
            const mes = await ctx.telegram.forwardMessage(
                `${admin}`,
                message.chat.id,
                message.message_id
            );
            mes.from ? (t = 0) : null;
        } catch (e) {
            console.log(e);
        }
    });
    await ctx.reply(
        "Ваше сообщение было отправлено администраторам!" +
            (t
                ? ""
                : "\nНо они не смогут вам ответить из-за ваших настроек конфиденциальности."),
        { reply_to_message_id: message.message_id }
    );
    //TODO: Сделать чтоб проверяло может ли пользователь получить ответ напрямую
    // if((ctx as Context).message)
});

bot.on(message("photo"), async (ctx) => {
    const message = ctx.message;
    if (
        message.media_group_id != "" &&
        message.chat.type == "group" &&
        admins.indexOf(message.from.id) !== 1
    ) {
        const posts = (requireUncached("./info.json") as StartData).posts;
        if (
            !(
                posts.filter(
                    (item) => item.media_group_id === message.media_group_id
                ).length > 0 ||
                (message.caption && message.caption.startsWith("/newpost "))
            )
        ) {
            return;
        }
        if (
            posts.filter(
                (item) => item.media_group_id === message.media_group_id
            ).length ||
            0 > 0
        ) {
            posts
                .filter(
                    (item) => item.media_group_id === message.media_group_id
                )[0]
                .photos.push(message.photo[2].file_id);
        } else {
            posts.push({
                media_group_id: message.media_group_id || "",
                caption: (message.caption || "").split("/newpost ", 2)[1],
                photos: [message.photo[2].file_id],
            });
        }
        save_data(posts);
    }
});

bot.command("info", (ctx) => {
    const posts = (requireUncached("./info.json") as StartData).posts;
    ctx.reply(JSON.stringify(posts) || "a");
});

bot.command("msginfo", (ctx) => {
    if (admins.indexOf(ctx.message.from.id) !== -1)
        ctx.reply(JSON.stringify(ctx.message, null, 2));
});

bot.command("sendpost", (ctx) => {
    const posts = (requireUncached("./info.json") as StartData).posts;
    if (posts.length === 0) {
        ctx.reply("нет постов");
        return;
    }
    const post = posts.splice(0, 1)[0];
    const media: InputMediaPhoto[] =
        post.photos.map((photo, index) => ({
            type: "photo",
            media: photo,
            caption: index === 0 ? post.caption || "" : "",
        })) || [];
    ctx.sendMediaGroup(media);
    save_data(posts);
});

bot.launch();

process.once("SIGINT", () => bot.stop("SIGINT"));
process.once("SIGTERM", () => bot.stop("SIGTERM"));
